package com.terry.test3;

import java.util.Arrays;
import java.util.Map;
import java.util.Scanner;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * 可以组成网络的服务器
 *
 * 在一个机房中，服务器的位置标识在 n*m 的整数矩阵网格中，
 * 1 表示单元格上有服务器，0 表示没有。
 * 如果两台服务器位于同一行或者同一列中紧邻的位置，则认为它们之间可以组成一个局域网。
 * 请你统计机房中最大的局域网包含的服务器个数。
 *
 * 输入描述:
 * 第一行输入两个正整数，n和m，0<n,m<=100
 * 之后为n*m的二维数组，代表服务器信息
 * 输出描述:
 * 最大局域网包含的服务器个数。
 * 示例1
 *
 * 输入
 * 2 2
 * 1 0
 * 1 1
 * 输出
 * 3
 * 说明
 * [0][0]、[1][0]、[1][1]三台服务器相互连接，可以组成局域网
 */
class DSU{
    public int[] parents;
    public DSU(int n){
        parents = new int[n+1];
        for(int i=0;i<=n;i++){
            parents[i] = i;
        }
    }

    public void union(int i,int j){
        int pi = find(i);
        int pj = find(j);
        if(pi != pj ){
            parents[pj] = parents[pi];
        }
    }

    public int find(int i){
        if(parents[i] != i){
            return find(parents[i]) ;
        }
        return i;
    }


}

public class Title27 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNextLine()){
            String[] splits = in.nextLine().split(" ");
            Integer n = Integer.parseInt(splits[0]);
            Integer m = Integer.parseInt(splits[1]);
            int[][] arr = new int[n][m];
            DSU dsu = new DSU(n*m+1);
            for(int i=0;i<n;i++){
                String[] temps = in.nextLine().split(" ");
                for(int j=0;j<m;j++){
                    arr[i][j] = Integer.parseInt(temps[j]);
                }
            }
            for(int i=0;i<n;i++){
                for(int j=0;j<m;j++){
                    if(arr[i][j] == 1){
                        if(i-1>=0 && arr[i-1][j] == 1){
                            dsu.union((i)*m + (j),(i-1)*m +(j));
                        }
                        if(j-1>=0 && arr[i][j-1] == 1){
                            dsu.union((i)*m + (j),(i)*m + (j-1));
                        }
                        if(i+1<n && arr[i+1][j] == 1){
                            dsu.union((i)*m + (j),(i+1)*m +(j));
                        }
                        if(j+1<m && arr[i][j+1] == 1){
                            dsu.union((i)*m + (j),(i)*m +(j+1));
                        }
                    }
                }
            }
            System.out.println(Arrays.stream(dsu.parents).boxed().collect(Collectors.groupingBy(Integer::valueOf, Collectors.counting())).values().stream().max((a, b) -> (int) (a - b)).get());

        }
    }
}
//2 2
//1 0
//1 1